home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 1 / BBS in a box - Trilogy I.iso / Files / Publish / J-L / lpr / lpr source / dialogs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-18  |  36.8 KB  |  1,618 lines  |  [TEXT/MPS ]
  1. #if !defined(USEDUMP)
  2.     #include "lprlib.h"
  3.     #include "lprdef.h"
  4.     #include "lprfuncs.h"
  5. #else
  6.     #pragma load "lprDumpFile"
  7. #endif
  8.  
  9. extern settings_list cs, ds;
  10. extern unsigned char tcpinitok;
  11. extern unsigned long passtime;
  12. extern unsigned char vmpass[];
  13. extern unsigned char grayflag;
  14. extern unsigned char bigscreen;
  15. extern unsigned long * Ticks;
  16. extern DialogPtr statptr;
  17. extern unsigned char netstat[], connstat[], prtstat[];
  18.  
  19. unsigned char passtext[32];
  20. unsigned char hidden;
  21.  
  22. unsigned char destflag;
  23. unsigned char headflag;
  24. unsigned char fmtstate;
  25.  
  26. void aboutdlg()
  27. {
  28. DialogPtr dlgptr;
  29. Ptr dStorage;
  30. WindowPtr behind;
  31. short itemHit;
  32. Handle version;
  33. short gtype;
  34. Handle gitem;
  35. Rect gbox;
  36. pascal Boolean (*filterProc) ();
  37. static unsigned short * DlgFont = 0xAFA;
  38. unsigned char msg[120];
  39. long l;
  40.  
  41. dStorage = 0;
  42. behind = (WindowPtr)-1;
  43. *DlgFont = 1;
  44. dlgptr = GetNewDialog(256, dStorage, behind);
  45. ctrwindow(dlgptr);
  46.  
  47. /* define version string */
  48. version = GetResource('lpra', 0);
  49. GetDItem(dlgptr, 4, >ype, &gitem, &gbox);
  50. SetIText(gitem, *version);
  51.  
  52. /* define available storage */
  53. MaxApplZone();
  54. l = FreeMem() >> 10;
  55. sprintf(msg, "Available storage = %ldK", l);
  56. GetDItem(dlgptr, 6, >ype, &gitem, &gbox);
  57. c2pstr(msg);
  58. SetIText(gitem, msg);
  59. p2cstr(msg);
  60.  
  61. /* show dialog */
  62. ShowWindow(dlgptr);
  63.  
  64. /* frame the default selection */
  65. framedflt(dlgptr);
  66.  
  67. filterProc = DlgFilter;
  68. ModalDialog((ModalFilterProcPtr)filterProc, &itemHit);
  69. DisposDialog(dlgptr);
  70. *DlgFont = 0;
  71. }
  72.  
  73. void statdlg(code, mask)
  74. unsigned char code, mask;
  75. {
  76. static DialogRecord dlgrec;
  77. Ptr dStorage;
  78. WindowPtr behind;
  79. GrafPtr temp;
  80. struct WStateData * wsptr;
  81. struct WindowRecord * stemp;
  82.  
  83. switch (code) {
  84.     case 0:    
  85.         if (statptr == 0) return;
  86.     case 1:
  87.         if (statptr == 0) {
  88.             dStorage = (Ptr)&dlgrec;
  89.             behind = (WindowPtr)-1;
  90.             statptr = GetNewDialog(275, dStorage, behind);
  91.             ctrwindow(statptr);
  92.             ShowWindow(statptr);
  93.             stemp = (struct WindowRecord *)statptr;
  94.             if (stemp->dataHandle != 0) {
  95.                 wsptr = (struct WStateData *)*(stemp->dataHandle);
  96.                 wsptr->stdState = statptr->portRect;
  97.                 GetPort(&temp);
  98.                 SetPort(statptr);
  99.                 LocalToGlobal((Point *)(&(wsptr->stdState.top)));
  100.                 LocalToGlobal((Point *)(&(wsptr->stdState.bottom)));
  101.                 SetPort(temp);
  102.                 }
  103.             }
  104.         if (mask & 0x01) settext(statptr, 2, netstat);
  105.         if (mask & 0x02) settext(statptr, 4, connstat);
  106.         if (mask & 0x04) settext(statptr, 6, prtstat);
  107.         statGrowIcon();
  108.         return;
  109.     default:
  110.         if (statptr == 0) return;
  111.         DisposDialog(statptr);
  112.         statptr = 0;
  113.         return;
  114.     }
  115. }
  116.  
  117. void settext(dlgptr, item, text)
  118. register DialogPtr dlgptr;
  119. register short item;
  120. register unsigned char *text;
  121. {
  122.     short gtype;
  123.     Handle gitem;
  124.     Rect gbox;
  125.  
  126.     GetDItem(dlgptr, item, >ype, &gitem, &gbox);
  127.     c2pstr(text);
  128.     SetIText(gitem, text);
  129.     p2cstr(text);
  130. }
  131.  
  132. short savedlg(void)
  133. {
  134. DialogPtr dlgptr;
  135. Ptr dStorage;
  136. WindowPtr behind;
  137. short itemHit;
  138. pascal Boolean (*filterProc) ();
  139.  
  140. dStorage = 0;
  141. behind = (WindowPtr)-1;
  142. dlgptr = GetNewDialog(264, dStorage, behind);
  143. ctrwindow(dlgptr);
  144. ShowWindow(dlgptr);
  145.  
  146. /* frame the default selection */
  147. framedflt(dlgptr);
  148.  
  149. /* loop to process changes */
  150.  
  151. filterProc = DlgFilter;
  152. while (1) {
  153.     ModalDialog((ModalFilterProcPtr)filterProc, &itemHit);
  154.     if (itemHit == 1) break;
  155.     if (itemHit == 2) break;
  156.     }
  157. /* dispose of dialog and return */
  158. DisposDialog(dlgptr);
  159. return(2 - itemHit);
  160. }
  161.  
  162. void orgdlg(void)
  163. {
  164. DialogPtr dlgptr;
  165. Ptr dStorage;
  166. WindowPtr behind;
  167. short itemHit;
  168. pascal Boolean (*filterProc) ();
  169. unsigned char d_orghost[64];
  170. unsigned char d_orguser[64];
  171.  
  172. filterProc = DlgFilter;
  173. dStorage = 0;
  174. behind = (WindowPtr)-1;
  175.  
  176. dlgptr = GetNewDialog(265, dStorage, behind);
  177. ctrwindow(dlgptr);
  178.  
  179. /* show current values of items */
  180. setorg(dlgptr, cs.orghost, cs.orguser);
  181.  
  182. /* show the dialog */
  183. ShowWindow(dlgptr);
  184.  
  185. repeat:        /* come here if string error */
  186.  
  187. /* frame the default selection */
  188. framedflt(dlgptr);
  189.  
  190. /* loop to process changes */
  191. while (1) {
  192.     ModalDialog((ModalFilterProcPtr)filterProc, &itemHit);
  193.     if (itemHit == 2) {
  194.         setorg(dlgptr, ds.orghost, ds.orguser);
  195.         }
  196.     else if (itemHit < 4) break;
  197.     }
  198.  
  199. if (itemHit == 3) {            /* cancel */
  200.     DisposDialog(dlgptr);
  201.     return;
  202.     }
  203.                             /* OK */
  204. if (getstring(dlgptr, 6, "Host name", d_orghost, 64)) goto repeat;
  205. if (getstring(dlgptr, 8, "User name", d_orguser, 64)) goto repeat;
  206. DisposDialog(dlgptr);
  207. memcpy(cs.orghost, d_orghost, 64);
  208. memcpy(cs.orguser, d_orguser, 64);
  209. }
  210.  
  211. void setorg(dlgptr, host, user)
  212. DialogPtr dlgptr;
  213. unsigned char * host, * user;
  214. {
  215. short gtype;
  216. Handle gitem;
  217. Rect gbox;
  218.  
  219. if (host != 0) {
  220.     GetDItem(dlgptr, 6, >ype, &gitem, &gbox);        /* host name */
  221.     c2pstr(host);
  222.     SetIText(gitem, host);
  223.     p2cstr(host);
  224.     }
  225.  
  226. if (user != 0) {
  227.     GetDItem(dlgptr, 8, >ype, &gitem, &gbox);        /* user name */
  228.     c2pstr(user);
  229.     SetIText(gitem, user);
  230.     p2cstr(user);
  231.     }
  232. }
  233.  
  234. void destdlg(needpass)
  235. unsigned char needpass;
  236. {
  237. DialogPtr dlgptr;
  238. Ptr dStorage;
  239. WindowPtr behind;
  240. short itemHit;
  241. unsigned char d_hostname[128];
  242. unsigned char d_printer[64];
  243. unsigned char d_vmflag;
  244. unsigned char d_vmuser[9];
  245. unsigned char d_vmpass[9];
  246. unsigned char d_newprot;
  247. short gtype;
  248. Handle gitem;
  249. Rect gbox;
  250. pascal Boolean (*filterProc) ();
  251. unsigned char resultstr[256];
  252. GrafPtr gp;
  253. unsigned char passclick;
  254. EventRecord clickevent;
  255.  
  256. filterProc = pDlgFilter;
  257. dStorage = 0;
  258. behind = (WindowPtr)-1;
  259.  
  260. dlgptr = GetNewDialog(266, dStorage, behind);
  261. ctrwindow(dlgptr);
  262.  
  263. /* define routine to draw user item */
  264. GetDItem(dlgptr, 10, >ype, &gitem, &gbox);
  265. gitem = (Handle)destuser;
  266. SetDItem(dlgptr, 10, gtype, gitem, &gbox);
  267. GetDItem(dlgptr, 12, >ype, &gitem, &gbox);
  268. gitem = (Handle)destuser;
  269. SetDItem(dlgptr, 12, gtype, gitem, &gbox);
  270.  
  271. /* show current values of items */
  272. hidden = (vmpass[0] != 0);
  273. if (hidden) 
  274.     setdest(dlgptr, cs.hostname, cs.printer, cs.vmflag, cs.vmuser,
  275.             "(hidden)", cs.newprot);
  276. else
  277.     setdest(dlgptr, cs.hostname, cs.printer, cs.vmflag, cs.vmuser,
  278.             "", cs.newprot);
  279. memset(passtext, 0, 32);
  280. strcpy(passtext, vmpass);
  281. d_vmflag = cs.vmflag;
  282. d_newprot = cs.newprot;
  283. passclick = 0;
  284.  
  285. /* if needpass set, generate event record to use, and  */
  286. /* change top text line                                   */
  287. if (needpass) {
  288.     clickevent.what = mouseDown;
  289.     clickevent.message = 0;
  290.     clickevent.when = *Ticks;
  291.     clickevent.modifiers = 0;
  292.     if (cs.vmuser[0])        /* select either password or userid */
  293.         GetDItem(dlgptr, 13, >ype, &gitem, &gbox);
  294.     else
  295.         GetDItem(dlgptr, 11, >ype, &gitem, &gbox);
  296.     clickevent.where.v = (gbox.top + gbox.bottom)/2;
  297.     clickevent.where.h = (gbox.left + gbox.right)/2;
  298.     GetPort(&gp);
  299.     SetPort(dlgptr);
  300.     LocalToGlobal(&clickevent.where);
  301.     SetPort(gp);
  302.     GetDItem(dlgptr, 4, >ype, &gitem, &gbox);
  303.     if (cs.vmuser[0]) {            /* need only password */
  304.         gbox.left -= 78;
  305.         gbox.right += 78;
  306.         SetDItem(dlgptr, 4, gtype, gitem, &gbox);
  307.         SetIText(gitem, "\pPlease enter the password for your userid:");
  308.         }
  309.     else {                        /* need both userid and password */
  310.         gbox.left -= 59;
  311.         gbox.right += 59;
  312.         SetDItem(dlgptr, 4, gtype, gitem, &gbox);
  313.         SetIText(gitem, "\pPlease enter your userid and password:");
  314.         }
  315.     }
  316.  
  317. /* show the dialog */
  318. ShowWindow(dlgptr);
  319. if (needpass) DialogSelect(&clickevent, &dlgptr, &itemHit);
  320.  
  321. repeat:        /* come here if string error */
  322.  
  323. /* frame the default selection */
  324. framedflt(dlgptr);
  325.  
  326. /* loop to process changes */
  327. while (1) {
  328.     ModalDialog((ModalFilterProcPtr)filterProc, &itemHit);
  329.     switch (itemHit) {
  330.         case 2:                /* set default */
  331.             setdest(dlgptr, ds.hostname, ds.printer, ds.vmflag,
  332.                     ds.vmuser, "", d_newprot);
  333.             memset(passtext, 0, 32);
  334.             hidden = 0;
  335.             d_vmflag = ds.vmflag;
  336.             d_newprot = ds.newprot;
  337.             break;
  338.         case 9:                /* vm printer flag */
  339.             d_vmflag ^= 1;
  340.             if (d_vmflag == 0) {
  341.                 setdest(dlgptr, 0L, 0L, d_vmflag, "", "", d_newprot);
  342.                 memset(passtext, 0, 32);
  343.                 }
  344.             else {
  345.                 hidden = (vmpass[0] != 0);
  346.                 if (hidden) 
  347.                     setdest(dlgptr, 0L, 0L, d_vmflag, cs.vmuser,
  348.                             "(hidden)", d_newprot);
  349.                 else
  350.                     setdest(dlgptr, 0L, 0L, d_vmflag, cs.vmuser, "",
  351.                             d_newprot);
  352.                 memset(passtext, 0, 32);
  353.                 strcpy(passtext, vmpass);
  354.                 }
  355.             break;
  356.         case 11:            /* userid */
  357.             if (d_vmflag == 0) {
  358.                 GetDItem(dlgptr, itemHit, >ype, &gitem, &gbox);
  359.                 GetIText(gitem, resultstr);
  360.                 p2cstr(resultstr);
  361.                 if (resultstr[0] != 0) {
  362.                     d_vmflag = 1;
  363.                     hidden = (vmpass[0] != 0);
  364.                     if (hidden) 
  365.                         setdest(dlgptr, 0L, 0L, d_vmflag, 0L,
  366.                                 "(hidden)", d_newprot);
  367.                     else
  368.                         setdest(dlgptr, 0L, 0L, d_vmflag, 0L, "",
  369.                                 d_newprot);
  370.                     memset(passtext, 0, 32);
  371.                     strcpy(passtext, vmpass);
  372.                     }
  373.                 }
  374.             break;
  375.         case 13:            /* password */
  376.             if (d_vmflag == 0) {
  377.                 GetDItem(dlgptr, itemHit, >ype, &gitem, &gbox);
  378.                 GetIText(gitem, resultstr);
  379.                 p2cstr(resultstr);
  380.                 if (resultstr[0] != 0) {
  381.                     d_vmflag = 1;
  382.                     hidden = 0;
  383.                     setdest(dlgptr, 0L, 0L, d_vmflag, cs.vmuser, 0L,
  384.                             d_newprot);
  385.                     }
  386.                 }
  387.             passclick = 1;
  388.             break;
  389.         case 14:                /* new protocol flag */
  390.             d_newprot ^= 1;
  391.             setdest(dlgptr, 0L, 0L, d_vmflag, 0L, 0L, d_newprot);
  392.             break;
  393.         default:
  394.             break;
  395.         }
  396.     if ((itemHit == 1) || (itemHit == 3)) break;
  397.     }
  398.  
  399. if (itemHit == 3) {            /* cancel */
  400.     DisposDialog(dlgptr);
  401.     return;
  402.     }
  403.                             /* OK */
  404. if (getstring(dlgptr, 6, "Host name", d_hostname, 128)) goto repeat;
  405. if (getstring(dlgptr, 8, "Printer name", d_printer, 64)) goto repeat;
  406. if (getstring(dlgptr, 11, "Userid", d_vmuser, 9)) goto repeat;
  407. if (checkstring(passtext, dlgptr, 13, "Password", d_vmpass, 9)) goto repeat;
  408. if ((d_vmuser[0] == 0) && (d_vmpass[0] == 0)) {
  409.     if (d_vmflag) {
  410.         stoperr(vmp1alrt);
  411.         goto repeat;
  412.         }
  413.     }
  414. else {
  415.     if (d_vmuser[0] == 0) {
  416.         stoperr(vmp1alrt);
  417.         SelIText(dlgptr, 11, 0, 32767);
  418.         goto repeat;
  419.         }
  420.     else if (d_vmpass[0] == 0) {
  421.         stoperr(vmp1alrt);
  422.         SelIText(dlgptr, 13, 0, 32767);
  423.         goto repeat;
  424.         }
  425.     else if (!d_vmflag) {
  426.         stoperr(vmp2alrt);
  427.         goto repeat;
  428.         }
  429.     }
  430. DisposDialog(dlgptr);
  431. memcpy(cs.hostname, d_hostname, 128);
  432. memcpy(cs.printer, d_printer, 64);
  433. memcpy(cs.vmuser, d_vmuser, 9);
  434. memcpy(vmpass, d_vmpass, 9);
  435. cs.vmflag = d_vmflag;
  436. cs.newprot = d_newprot;
  437. if (cs.vmflag && passclick) passtime = *Ticks;
  438. else if (!cs.vmflag) passtime = 0;
  439. }
  440.  
  441. void setdest(dlgptr, hostname, printer, vmflag, vmuser, vmpass, newprot)
  442. DialogPtr dlgptr;
  443. unsigned char * hostname, * printer, * vmuser, * vmpass;
  444. unsigned char vmflag, newprot;
  445. {
  446. short gtype;
  447. Handle gitem;
  448. Rect gbox;
  449.  
  450. if (hostname != 0) {
  451.     GetDItem(dlgptr, 6, >ype, &gitem, &gbox);        /* host name */
  452.     c2pstr(hostname);
  453.     SetIText(gitem, hostname);
  454.     p2cstr(hostname);
  455.     }
  456.  
  457. if (printer != 0) {
  458.     GetDItem(dlgptr, 8, >ype, &gitem, &gbox);        /* printer name */
  459.     c2pstr(printer);
  460.     SetIText(gitem, printer);
  461.     p2cstr(printer);
  462.     }
  463.  
  464. GetDItem(dlgptr, 9, >ype, &gitem, &gbox);        /* vm printer flag */
  465. SetCtlValue((ControlHandle)gitem, vmflag);
  466. destflag = vmflag;
  467. GetDItem(dlgptr, 14, >ype, &gitem, &gbox);    /* new protocol flag */
  468. SetCtlValue((ControlHandle)gitem, newprot);
  469. destuser(dlgptr, 10);                            /* userid label */
  470. destuser(dlgptr, 12);                            /* password label */
  471.  
  472. if (vmuser != 0) {
  473.     GetDItem(dlgptr, 11, >ype, &gitem, &gbox);        /* userid */
  474.     c2pstr(vmuser);
  475.     SetIText(gitem, vmuser);
  476.     p2cstr(vmuser);
  477.     }
  478.  
  479. if (vmpass != 0) {    
  480.     GetDItem(dlgptr, 13, >ype, &gitem, &gbox);        /* password */
  481.     c2pstr(vmpass);
  482.     SetIText(gitem, vmpass);
  483.     p2cstr(vmpass);
  484.     }
  485. }
  486.  
  487. void headdlg()
  488. {
  489. DialogPtr dlgptr;
  490. Ptr dStorage;
  491. WindowPtr behind;
  492. short gtype;
  493. Handle gitem;
  494. Rect gbox;
  495. short itemHit;
  496. pascal Boolean (*filterProc) ();
  497. short i;
  498. unsigned char resultstr[256];
  499. unsigned char d_hdrflag;
  500. unsigned char d_hdrid[64];
  501. unsigned char d_jobname[64];
  502. unsigned char d_hdrclass[64];
  503. unsigned char *tid, *tname, *tclass;
  504.  
  505. filterProc = DlgFilter;
  506. dStorage = 0;
  507. behind = (WindowPtr)-1;
  508.  
  509. dlgptr = GetNewDialog(267, dStorage, behind);
  510. ctrwindow(dlgptr);
  511.  
  512. /* define routine to draw user item */
  513. for (i = 6; i <= 10; i += 2) {
  514.     GetDItem(dlgptr, i, >ype, &gitem, &gbox);
  515.     gitem = (Handle)headuser;
  516.     SetDItem(dlgptr, i, gtype, gitem, &gbox);
  517.     }
  518.  
  519. /* show current values of items */
  520. sethead(dlgptr, cs.hdrflag, cs.hdrid, cs.jobname, cs.hdrclass);
  521. d_hdrflag = cs.hdrflag;
  522.  
  523. /* show the dialog */
  524. ShowWindow(dlgptr);
  525.  
  526. repeat:        /* come here if string error */
  527.  
  528. /* frame the default selection */
  529. framedflt(dlgptr);
  530.  
  531. /* loop to process changes */
  532. while (1) {
  533.     ModalDialog((ModalFilterProcPtr)filterProc, &itemHit);
  534.     switch(itemHit) {
  535.         case 2:                /* set defaults */
  536.             sethead(dlgptr, ds.hdrflag, ds.hdrid, ds.jobname, ds.hdrclass);
  537.             d_hdrflag = ds.hdrflag;
  538.             break;
  539.         case 5:                /* generate header flag */
  540.             d_hdrflag ^= 1;
  541.             if (d_hdrflag == 0) sethead(dlgptr, d_hdrflag, "", "", "");
  542.             else sethead(dlgptr, d_hdrflag, cs.hdrid, cs.jobname, cs.hdrclass);
  543.             break;
  544.         case 7:                /* identification */
  545.         case 9:                /* job name */
  546.         case 11:            /* classification */
  547.             if (d_hdrflag == 0) {
  548.                 GetDItem(dlgptr, itemHit, >ype, &gitem, &gbox);
  549.                 GetIText(gitem, resultstr);
  550.                 p2cstr(resultstr);
  551.                 if (resultstr[0] != 0) {
  552.                     d_hdrflag = 1;
  553.                     tid = cs.hdrid;
  554.                     tname = cs.jobname;
  555.                     tclass = cs.hdrclass;
  556.                     switch (itemHit) {
  557.                         case 7:
  558.                             tid = 0;
  559.                             break;
  560.                         case 9:
  561.                             tname = 0;
  562.                             break;
  563.                         case 11:
  564.                             tclass = 0;
  565.                             break;
  566.                         default:
  567.                             break;
  568.                         }
  569.                     sethead(dlgptr, d_hdrflag, tid, tname, tclass);
  570.                     }
  571.                 }
  572.             break;
  573.         default:
  574.             break;
  575.         }
  576.     if ((itemHit == 1) || (itemHit == 3)) break;
  577.     }
  578.  
  579. if (itemHit == 3) {            /* cancel */
  580.     DisposDialog(dlgptr);
  581.     return;
  582.     }
  583.                             /* OK */
  584. if (getstring(dlgptr, 7, "Identification", d_hdrid, 64)) goto repeat;
  585. if (getstring(dlgptr, 9, "Job name", d_jobname, 64)) goto repeat;
  586. if (getstring(dlgptr, 11, "Classification", d_hdrclass, 64)) goto repeat;
  587. DisposDialog(dlgptr);
  588. cs.hdrflag = d_hdrflag;
  589. memcpy(cs.hdrid, d_hdrid, 64);
  590. memcpy(cs.jobname, d_jobname, 64);
  591. memcpy(cs.hdrclass, d_hdrclass, 64);
  592. }
  593.  
  594. void sethead(dlgptr, hdrflag, hdrid, jobname, hdrclass)
  595. DialogPtr dlgptr;
  596. unsigned char hdrflag;
  597. unsigned char * hdrid, * jobname, * hdrclass;
  598. {
  599. short gtype;
  600. Handle gitem;
  601. Rect gbox;
  602.  
  603. GetDItem(dlgptr, 5, >ype, &gitem, &gbox);        /*  generate header flag */
  604. SetCtlValue((ControlHandle)gitem, hdrflag);
  605. headflag = hdrflag;
  606. headuser(dlgptr, 6);                            /* identification */
  607. headuser(dlgptr, 8);                            /* job name */
  608. headuser(dlgptr, 10);                            /* classification */
  609.  
  610. if (hdrid != 0) {
  611.     GetDItem(dlgptr, 7, >ype, &gitem, &gbox);        /* identification */
  612.     c2pstr(hdrid);
  613.     SetIText(gitem, hdrid);
  614.     p2cstr(hdrid);
  615.     }
  616.  
  617. if (jobname!= 0) {
  618.     GetDItem(dlgptr, 9, >ype, &gitem, &gbox);        /* job name */
  619.     c2pstr(jobname);
  620.     SetIText(gitem, jobname);
  621.     p2cstr(jobname);
  622.     }
  623.  
  624. if (hdrclass != 0) {
  625.     GetDItem(dlgptr, 11, >ype, &gitem, &gbox);    /* classification */    
  626.     c2pstr(hdrclass);
  627.     SetIText(gitem, hdrclass);
  628.     p2cstr(hdrclass);
  629.     }
  630. }
  631.  
  632. void fmtdlg()
  633. {
  634. DialogPtr dlgptr;
  635. Ptr dStorage;
  636. WindowPtr behind;
  637. short gtype;
  638. Handle gitem;
  639. Rect gbox;
  640. short itemHit;
  641. pascal Boolean (*filterProc) ();
  642. short i;
  643. unsigned char d_fmttype;
  644. unsigned char d_fmttitle[64];
  645. unsigned char d_findent;
  646. unsigned char d_ftop;
  647. unsigned char d_fwidth;
  648. unsigned char d_fpgsize;
  649. unsigned char d_splitflag;
  650. unsigned char d_pascalflag;
  651. unsigned char d_ftabsize;
  652. unsigned char d_duplex;
  653. unsigned char d_noff;
  654. unsigned char needmac;
  655. unsigned char * ttitle;
  656. short tindent, ttop, twidth, tpgsize, ttabsize;
  657. unsigned char resultstr[256];
  658.  
  659. filterProc = DlgFilter;
  660. dStorage = 0;
  661. behind = (WindowPtr)-1;
  662.  
  663. dlgptr = GetNewDialog(268, dStorage, behind);
  664. ctrwindow(dlgptr);
  665.  
  666. /* define routine to draw user item */
  667. for (i = 8; i <= 16; i += 2) {
  668.     GetDItem(dlgptr, i, >ype, &gitem, &gbox);
  669.     gitem = (Handle)fmtuser;
  670.     SetDItem(dlgptr, i, gtype, gitem, &gbox);
  671.     }
  672. GetDItem(dlgptr, 20, >ype, &gitem, &gbox);
  673. gitem = (Handle)fmtuser;
  674. SetDItem(dlgptr, 20, gtype, gitem, &gbox);
  675.  
  676. /* show current values of items */
  677. setfmt(dlgptr, cs.fmttype, cs.fmttitle, cs.findent, cs.ftop,
  678.        cs.fwidth, cs.fpgsize, cs.splitflag, cs.pascalflag, cs.ftabsize,
  679.        cs.duplex, cs.noff);
  680. d_fmttype = cs.fmttype;
  681. d_splitflag = cs.splitflag;
  682. d_pascalflag = cs.pascalflag;
  683. d_duplex = cs.duplex;
  684. d_noff = cs.noff;
  685.  
  686. /* show the dialog */
  687. ShowWindow(dlgptr);
  688.  
  689. repeat:        /* come here if string error */
  690.  
  691. /* frame the default selection */
  692. framedflt(dlgptr);
  693.  
  694. /* loop to process changes */
  695. while (1) {
  696.     ModalDialog((ModalFilterProcPtr)filterProc, &itemHit);
  697.     switch(itemHit) {
  698.         case 2:                    /* set defaults */
  699.             setfmt(dlgptr, ds.fmttype, ds.fmttitle, ds.findent, ds.ftop,
  700.                    ds.fwidth, ds.fpgsize, ds.splitflag, ds.pascalflag,
  701.                 ds.ftabsize, ds.duplex, ds.noff);
  702.             d_fmttype = ds.fmttype;
  703.             d_splitflag = ds.splitflag;
  704.             d_pascalflag = ds.pascalflag;
  705.             d_duplex = ds.duplex;
  706.             d_noff = ds.noff;
  707.             break;
  708.         case 5:                    /* none */
  709.             if (d_fmttype == 1) break;
  710.             setfmt(dlgptr, 1, "", 0, 0, 0, 0, 0, 0, 0, 0, cs.noff);
  711.             d_fmttype = 1;
  712.             d_splitflag = 0;
  713.             d_pascalflag = 0;
  714.             d_duplex = 0;
  715.             d_noff = cs.noff;
  716.             break;
  717.         case 6:                    /* on Mac */
  718.             if (d_fmttype == 2) break;
  719.             setfmt(dlgptr, 2, cs.fmttitle, cs.findent, cs.ftop, cs.fwidth,
  720.                 cs.fpgsize, cs.splitflag, cs.pascalflag, cs.ftabsize,
  721.                 cs.duplex, 0);
  722.             d_fmttype = 2;
  723.             d_splitflag = cs.splitflag;
  724.             d_pascalflag = cs.pascalflag;
  725.             d_duplex = cs.duplex;
  726.             d_noff = 0;
  727.             break;
  728.         case 7:                    /* remote */
  729.             if (d_fmttype == 3) break;
  730.             setfmt(dlgptr, 3, cs.fmttitle, cs.findent, 0, cs.fwidth, 0,
  731.                    0, 0, 0, 0, cs.noff);
  732.             d_fmttype = 3;
  733.             d_splitflag = 0;
  734.             d_pascalflag = 0;
  735.             d_duplex = 0;
  736.             d_noff = cs.noff;
  737.             break;
  738.         case 9:                    /* title */
  739.         case 11:                /* indent */
  740.         case 13:                /* top margin */
  741.         case 15:                /* width */
  742.         case 17:                /* page length */
  743.         case 21:                /* tab spacing */
  744.             needmac = ((itemHit == 13) || (itemHit == 17) || (itemHit == 21));
  745.             if ((d_fmttype == 1) || ((d_fmttype == 3) && needmac)) {
  746.                 GetDItem(dlgptr, itemHit, >ype, &gitem, &gbox);
  747.                 GetIText(gitem, resultstr);
  748.                 p2cstr(resultstr);
  749.                 if (resultstr[0] != 0) {
  750.                     ttitle = cs.fmttitle;
  751.                     tindent = cs.findent;
  752.                     ttop = cs.ftop;
  753.                     twidth = cs.fwidth;
  754.                     tpgsize = cs.fpgsize;
  755.                     ttabsize = cs.ftabsize;
  756.                     switch (itemHit) {
  757.                         case 9:
  758.                             ttitle = 0;
  759.                             break;
  760.                         case 11:
  761.                             tindent = -1;
  762.                             break;
  763.                         case 13:
  764.                             ttop = -1;
  765.                             break;
  766.                         case 15:
  767.                             twidth = -1;
  768.                             break;
  769.                         case 17:
  770.                             tpgsize = -1;
  771.                             break;
  772.                         case 21:
  773.                             ttabsize = -1;
  774.                             break;
  775.                         default:
  776.                             break;
  777.                         }
  778.                     setfmt(dlgptr, 2, ttitle, tindent, ttop, twidth,
  779.                            tpgsize, cs.splitflag, cs.pascalflag,
  780.                            ttabsize, cs.duplex, cs.noff);
  781.                     d_fmttype = 2;
  782.                     d_splitflag = cs.splitflag;
  783.                     d_pascalflag = cs.pascalflag;
  784.                     d_duplex = cs.duplex;
  785.                     d_noff = cs.noff;
  786.                     }
  787.                 }
  788.             break;
  789.         case 18:
  790.             d_splitflag ^= 1;
  791.             setfmt(dlgptr, d_fmttype, 0L, -1, -1, -1, -1,
  792.                     d_splitflag, d_pascalflag, -1, d_duplex, d_noff);
  793.             break;
  794.         case 19:
  795.             d_pascalflag ^= 1;
  796.             setfmt(dlgptr, d_fmttype, 0L, -1, -1, -1, -1,
  797.                     d_splitflag, d_pascalflag, -1, d_duplex, d_noff);
  798.             break;
  799.         case 22:
  800.             d_duplex ^= 1;
  801.             setfmt(dlgptr, d_fmttype, 0L, -1, -1, -1, -1,
  802.                     d_splitflag, d_pascalflag, -1, d_duplex, d_noff);
  803.             break;
  804.         case 23:
  805.             d_noff ^= 1;
  806.             setfmt(dlgptr, d_fmttype, 0L, -1, -1, -1, -1,
  807.                     d_splitflag, d_pascalflag, -1, d_duplex, d_noff);
  808.             break;
  809.         default:
  810.             break;
  811.         }
  812.     if ((itemHit == 1) || (itemHit == 3)) break;
  813.     }
  814.  
  815. if (itemHit == 3) {            /* cancel */
  816.     DisposDialog(dlgptr);
  817.     return;
  818.     }
  819.                             /* OK */
  820. if (getstring(dlgptr, 9, "Title", d_fmttitle, 64)) goto repeat;
  821. if (getcnum(dlgptr, 11, "Indent", &d_findent, 0, 63)) goto repeat;
  822. if (getcnum(dlgptr, 13, "Top margin", &d_ftop, 0, 13-MARGIN)) goto repeat;
  823. if (getcnum(dlgptr, 15, "Width", &d_fwidth, 64, 128)) goto repeat; 
  824. if (getcnum(dlgptr, 17, "Page length", &d_fpgsize, 16, 255)) goto repeat; 
  825. if (getcnum(dlgptr, 21, "Tab spacing", &d_ftabsize, 1, 32)) goto repeat; 
  826. DisposDialog(dlgptr);
  827. cs.fmttype = d_fmttype;
  828. memcpy(cs.fmttitle, d_fmttitle, 64);
  829. cs.findent = d_findent;
  830. cs.ftop = d_ftop;
  831. cs.fwidth = d_fwidth;
  832. cs.fpgsize = d_fpgsize;
  833. cs.splitflag = d_splitflag;
  834. cs.pascalflag = d_pascalflag;
  835. cs.duplex = d_duplex;
  836. cs.noff = d_noff;
  837. cs.ftabsize = d_ftabsize;
  838. }
  839.  
  840. void setfmt(dlgptr, fmttype, title, indent, top, width, pgsize,
  841.             splitflg, pascalflg, tabsize, duplex, noff)
  842. DialogPtr dlgptr;
  843. unsigned char fmttype, splitflg, pascalflg, duplex;
  844. short indent, top, width, pgsize, tabsize;
  845. unsigned char * title;
  846. {
  847. short gtype;
  848. Handle gitem;
  849. Rect gbox;
  850. unsigned char numfmt[8];
  851.  
  852. GetDItem(dlgptr, 5, >ype, &gitem, &gbox);            /* formatting type */
  853. SetCtlValue((ControlHandle)gitem, fmttype == 1);
  854. GetDItem(dlgptr, 6, >ype, &gitem, &gbox);
  855. SetCtlValue((ControlHandle)gitem, fmttype == 2);
  856. GetDItem(dlgptr, 7, >ype, &gitem, &gbox);
  857. SetCtlValue((ControlHandle)gitem, fmttype == 3);
  858.  
  859. fmtstate = fmttype;                /* for user items */
  860.  
  861. fmtuser(dlgptr, 8);
  862. if (title != 0) {
  863.     GetDItem(dlgptr, 9, >ype, &gitem, &gbox);        /* title */
  864.     c2pstr(title);
  865.     SetIText(gitem, title);
  866.     p2cstr(title);
  867.     }
  868.  
  869. fmtuser(dlgptr, 10);
  870. if (indent >= 0) {
  871.     GetDItem(dlgptr, 11, >ype, &gitem, &gbox);    /* indent */
  872.     if ((fmttype != 1) || (indent > 0)) {
  873.         sprintf(numfmt, "%d", indent);
  874.         c2pstr(numfmt);
  875.         SetIText(gitem, numfmt);
  876.         p2cstr(numfmt);
  877.         }
  878.     else SetIText(gitem, "\p");
  879.     }
  880.  
  881. fmtuser(dlgptr, 12);
  882. if (top >= 0) {
  883.     GetDItem(dlgptr, 13, >ype, &gitem, &gbox);    /* top */
  884.     if ((fmttype == 2) || (top > 0)) {
  885.         sprintf(numfmt, "%d", top);
  886.         c2pstr(numfmt);
  887.         SetIText(gitem, numfmt);
  888.         p2cstr(numfmt);
  889.         }
  890.     else SetIText(gitem, "\p");
  891.     }
  892.  
  893. fmtuser(dlgptr, 14);
  894. if (width >= 0) {
  895.     GetDItem(dlgptr, 15, >ype, &gitem, &gbox);    /* width */
  896.     if ((fmttype != 1) || (width > 0)) {
  897.         if (width == 0) width = ds.fwidth;
  898.         sprintf(numfmt, "%d", width);
  899.         c2pstr(numfmt);
  900.         SetIText(gitem, numfmt);
  901.         p2cstr(numfmt);
  902.         }
  903.     else SetIText(gitem, "\p");
  904.     }
  905.  
  906. fmtuser(dlgptr, 16);
  907. if (pgsize >= 0) {
  908.     GetDItem(dlgptr, 17, >ype, &gitem, &gbox);    /* pgsize */
  909.     if ((fmttype == 2) || (pgsize > 0)) {
  910.         if (pgsize == 0) pgsize = ds.fpgsize;
  911.         sprintf(numfmt, "%d", pgsize);
  912.         c2pstr(numfmt);
  913.         SetIText(gitem, numfmt);
  914.         p2cstr(numfmt);
  915.         }
  916.     else SetIText(gitem, "\p");
  917.     }
  918.  
  919. GetDItem(dlgptr, 18, >ype, &gitem, &gbox);        /* split line flag */
  920. if ((fmttype == 2) || splitflg) {
  921.     SetCtlValue((ControlHandle)gitem, splitflg);
  922.     HiliteControl((ControlHandle)gitem, 0);
  923.     }
  924. else {
  925.     SetCtlValue((ControlHandle)gitem, 0);
  926.     HiliteControl((ControlHandle)gitem, 255);
  927.     }
  928.  
  929. GetDItem(dlgptr, 19, >ype, &gitem, &gbox);        /* pascal flag */
  930. if ((fmttype == 2) || pascalflg) {
  931.     SetCtlValue((ControlHandle)gitem, pascalflg);
  932.     HiliteControl((ControlHandle)gitem, 0);
  933.     }
  934. else {
  935.     SetCtlValue((ControlHandle)gitem, 0);
  936.     HiliteControl((ControlHandle)gitem, 255);
  937.     }
  938.  
  939. fmtuser(dlgptr, 20);
  940. if (tabsize >= 0) {
  941.     GetDItem(dlgptr, 21, >ype, &gitem, &gbox);    /* tabsize */
  942.     if ((fmttype == 2) || (tabsize > 0)) {
  943.         if (tabsize == 0) tabsize = ds.ftabsize;
  944.         sprintf(numfmt, "%d", tabsize);
  945.         c2pstr(numfmt);
  946.         SetIText(gitem, numfmt);
  947.         p2cstr(numfmt);
  948.         }
  949.     else SetIText(gitem, "\p");
  950.     }
  951.  
  952. GetDItem(dlgptr, 22, >ype, &gitem, &gbox);        /* duplex flag */
  953. if ((fmttype == 2) || duplex) {
  954.     SetCtlValue((ControlHandle)gitem, duplex);
  955.     HiliteControl((ControlHandle)gitem, 0);
  956.     }
  957. else {
  958.     SetCtlValue((ControlHandle)gitem, 0);
  959.     HiliteControl((ControlHandle)gitem, 255);
  960.     }
  961.  
  962. GetDItem(dlgptr, 23, >ype, &gitem, &gbox);        /* noff flag */
  963. if ((fmttype != 2) || noff) {
  964.     SetCtlValue((ControlHandle)gitem, noff);
  965.     HiliteControl((ControlHandle)gitem, 0);
  966.     }
  967. else {
  968.     SetCtlValue((ControlHandle)gitem, 0);
  969.     HiliteControl((ControlHandle)gitem, 255);
  970.     }
  971. }
  972.  
  973. void ctldlg()
  974. {
  975. DialogPtr dlgptr;
  976. Ptr dStorage;
  977. WindowPtr behind;
  978. short itemHit;
  979. pascal Boolean (*filterProc) ();
  980. short dlgnum;
  981. unsigned char d_copycnt;
  982. unsigned char d_vmclass[2];
  983. unsigned char d_vmform[9];
  984.  
  985. filterProc = DlgFilter;
  986. dStorage = 0;
  987. behind = (WindowPtr)-1;
  988. if (cs.vmflag) dlgnum = 269;
  989. else dlgnum = 274;
  990.  
  991. dlgptr = GetNewDialog(dlgnum, dStorage, behind);
  992. ctrwindow(dlgptr);
  993.  
  994. /* show current values of items */
  995. setctl(dlgptr, cs.copycnt, cs.vmclass, cs.vmform);
  996.  
  997. /* show the dialog */
  998. ShowWindow(dlgptr);
  999.  
  1000. repeat:        /* come here if string error */
  1001.  
  1002. /* frame the default selection */
  1003. framedflt(dlgptr);
  1004.  
  1005. /* loop to process changes */
  1006. while (1) {
  1007.     ModalDialog((ModalFilterProcPtr)filterProc, &itemHit);
  1008.     switch(itemHit) {
  1009.         case 2:
  1010.             setctl(dlgptr, ds.copycnt, ds.vmclass, ds.vmform);
  1011.             break;
  1012.         case 12:
  1013.             infodlg(270);
  1014.             framedflt(dlgptr);
  1015.             break;
  1016.         case 13:
  1017.             infodlg(271);
  1018.             framedflt(dlgptr);
  1019.             break;
  1020.         default:
  1021.             break;
  1022.         }
  1023.     if ((itemHit == 1) || (itemHit == 3)) break;
  1024.     }
  1025.  
  1026. if (itemHit == 3) {            /* cancel */
  1027.     DisposDialog(dlgptr);
  1028.     return;
  1029.     }
  1030.                             /* OK */
  1031. if (getcnum(dlgptr, 6, "Copies", &d_copycnt, 1, 4)) goto repeat;
  1032. if (cs.vmflag) {
  1033.     if (getstring(dlgptr, 9, "Class", d_vmclass, 2)) goto repeat;
  1034.     if (getstring(dlgptr, 11, "Form", d_vmform, 9)) goto repeat;
  1035.     }
  1036. DisposDialog(dlgptr);
  1037. cs.copycnt = d_copycnt;
  1038. if (cs.vmflag) {
  1039.     memcpy(cs.vmclass, d_vmclass, 2);
  1040.     memcpy(cs.vmform, d_vmform, 9);
  1041.     }
  1042. }
  1043.  
  1044. void setctl(dlgptr, copycnt, vmclass, vmform)
  1045. DialogPtr dlgptr;
  1046. unsigned char copycnt;
  1047. unsigned char * vmclass, * vmform;
  1048. {
  1049. short gtype;
  1050. Handle gitem;
  1051. Rect gbox;
  1052. unsigned char numfmt[8];
  1053.  
  1054. if (copycnt >= 0) {
  1055.     GetDItem(dlgptr, 6, >ype, &gitem, &gbox);        /* copy count */
  1056.     if (copycnt == 0) copycnt = ds.copycnt;
  1057.     sprintf(numfmt, "%d", copycnt);
  1058.     c2pstr(numfmt);
  1059.     SetIText(gitem, numfmt);
  1060.     p2cstr(numfmt);
  1061.     }
  1062.  
  1063. if (!cs.vmflag) return;
  1064.  
  1065. if (vmclass != 0) {
  1066.     GetDItem(dlgptr, 9, >ype, &gitem, &gbox);        /* VM class */
  1067.     c2pstr(vmclass);
  1068.     SetIText(gitem, vmclass);
  1069.     p2cstr(vmclass);
  1070.     }
  1071.  
  1072. if (vmform != 0) {
  1073.     GetDItem(dlgptr, 11, >ype, &gitem, &gbox);    /* VM form */
  1074.     c2pstr(vmform);
  1075.     SetIText(gitem, vmform);
  1076.     p2cstr(vmform);
  1077.     }
  1078. }
  1079.  
  1080. void infodlg(num)
  1081. short num;
  1082. {
  1083. DialogPtr dlgptr;
  1084. Ptr dStorage;
  1085. WindowPtr behind;
  1086. short itemHit;
  1087. pascal Boolean (*filterProc) ();
  1088.  
  1089. filterProc = DlgFilter;
  1090. dStorage = 0;
  1091. behind = (WindowPtr)-1;
  1092. dlgptr = GetNewDialog(num, dStorage, behind);
  1093. ctrwindow(dlgptr);
  1094. ShowWindow(dlgptr);
  1095.  
  1096. /* frame the default selection */
  1097. framedflt(dlgptr);
  1098.  
  1099. ModalDialog((ModalFilterProcPtr)filterProc, &itemHit);
  1100. DisposDialog(dlgptr);
  1101. }
  1102.  
  1103. void stgalert(kind, routine, amount)
  1104. unsigned char * kind;
  1105. unsigned char * routine;
  1106. long amount;
  1107. {
  1108. pascal Boolean (*filterProc) ();
  1109. unsigned char message[80];
  1110.  
  1111. filterProc = DlgFilter;
  1112. resetcurs();            /* restore normal cursor */
  1113. sprintf(message, "%s attempt to allocate %ld bytes for %s failed.",
  1114.         routine, amount, kind);
  1115. dbdlg(message);
  1116. StopAlert(263, (ModalFilterProcPtr)filterProc);
  1117. }
  1118.  
  1119. short quitdlg(void)
  1120.             /* if a file is still being printed, verify user wants to quit */
  1121. {
  1122. short item;
  1123. pascal Boolean (*filterProc) ();
  1124.  
  1125. filterProc = DlgFilter;
  1126. item = CautionAlert(272, (ModalFilterProcPtr)filterProc);
  1127. if (item == 1) return(0);        /* Cancel */
  1128. else return(1);                    /* Really Quit */
  1129. }
  1130.  
  1131. short vmuserdlg(void)
  1132. {
  1133. DialogPtr dlgptr;
  1134. Ptr dStorage;
  1135. WindowPtr behind;
  1136. short itemHit;
  1137. pascal Boolean (*filterProc) ();
  1138.  
  1139. filterProc = DlgFilter;
  1140. dStorage = 0;
  1141. behind = (WindowPtr)-1;
  1142. dlgptr = GetNewDialog(273, dStorage, behind);
  1143. ctrwindow(dlgptr);
  1144. ShowWindow(dlgptr);
  1145.  
  1146. /* frame the default selection */
  1147. framedflt(dlgptr);
  1148.  
  1149. ModalDialog((ModalFilterProcPtr)filterProc, &itemHit);
  1150. DisposDialog(dlgptr);
  1151. return(itemHit-1);
  1152. }
  1153.  
  1154. void dbdlg(string)
  1155. unsigned char *string;
  1156. {
  1157.    DialogRecord dStorage;
  1158.    Rect boundry;
  1159.    unsigned char visible = 0, goAway = 0;
  1160.    WindowPtr behind = (-1);
  1161.    struct {
  1162.       short numitems;
  1163.       /* Button stuff */
  1164.       long Bhandle;
  1165.       short Btop,
  1166.             Bleft,
  1167.             Bbottom,
  1168.             Bright;
  1169.       unsigned char Btype;
  1170.       unsigned char Blen;
  1171.       unsigned char Btext[2];
  1172.       /* Text item */
  1173.       long Thandle;
  1174.       short Ttop,
  1175.             Tleft,
  1176.             Tbottom,
  1177.             Tright;
  1178.       unsigned char Ttype;
  1179.       unsigned char Tlen;
  1180.       unsigned char Ttext[255];
  1181.       } DStruct;
  1182.    DialogPtr theBox;
  1183.    short dummy, l;
  1184.    Size DSsize;
  1185.    Handle itemlist;
  1186.    pascal Boolean (*filterProc) ();
  1187.    
  1188.    filterProc = DlgFilter;
  1189.  
  1190.    if (cs.dblevel == 0) return;
  1191.  
  1192.    DStruct.numitems = 1;
  1193.    DStruct.Thandle =  0;
  1194.    DStruct.Ttop = 50;
  1195.    DStruct.Tleft = 30;
  1196.    DStruct.Tbottom = 100;
  1197.    DStruct.Tright = 260;
  1198.    DStruct.Ttype =    statText + itemDisable;
  1199.    l = strlen(string);
  1200.    if (l > 254) l = 254;
  1201.    strcpy(DStruct.Ttext, string);
  1202.    if (l%2) {
  1203.        strcat(DStruct.Ttext, " ");
  1204.        l++;
  1205.        }
  1206.    DStruct.Tlen = l;
  1207.    DStruct.Bhandle = 0;
  1208.    DStruct.Btop = 10;
  1209.    DStruct.Bleft = 160;
  1210.    DStruct.Bbottom = 30;
  1211.    DStruct.Bright = 240;
  1212.    DStruct.Btype = ctrlItem + btnCtrl;
  1213.    DStruct.Blen = 2;
  1214.    DStruct.Btext[0] = 'O';
  1215.    DStruct.Btext[1] = 'K';
  1216.  
  1217.    boundry.top = 120;
  1218.    boundry.left = 120;
  1219.    boundry.bottom = 240;
  1220.    boundry.right = 400;
  1221.  
  1222.    DSsize = sizeof(DStruct) - 255 + l;
  1223.    itemlist = NewHandle(DSsize);
  1224.  
  1225.    memcpy(*itemlist, &DStruct, (short) DSsize);
  1226.  
  1227.  
  1228.    theBox = newdialog((Ptr)&dStorage, &boundry, "Debug Text",
  1229.                       visible, dBoxProc, behind, goAway, 0L, itemlist);
  1230.     ctrwindow(theBox);
  1231.     ShowWindow(theBox);
  1232.  
  1233.    /* highlight the default item */
  1234.    framedflt(theBox);
  1235.  
  1236.    ModalDialog((ModalFilterProcPtr)filterProc, &dummy);
  1237.  
  1238.    DisposDialog(theBox);
  1239. }
  1240.  
  1241. void stoperr(code)
  1242. short code;
  1243. {
  1244. pascal Boolean (*filterProc) ();
  1245. Handle errtext;
  1246. static unsigned char nullstr[1] = {0};
  1247.  
  1248. errtext = GetResource('STR ', code);
  1249. if (errtext == 0) return;
  1250. ParamText(*errtext, nullstr, nullstr, nullstr);
  1251.  
  1252. filterProc = DlgFilter;
  1253. resetcurs();        /* restore normal cursor */
  1254. StopAlert(258, (ModalFilterProcPtr)filterProc);
  1255.  
  1256. ParamText(nullstr, nullstr, nullstr, nullstr);
  1257. }
  1258.  
  1259. pascal Boolean DlgFilter(dlg, eventptr, itemptr)
  1260. DialogPtr dlg;
  1261. EventRecord * eventptr;
  1262. short * itemptr;
  1263. {
  1264. unsigned char i;
  1265. DialogPtr temp;
  1266.  
  1267. temp = dlg;        /* avoid compiler warning */
  1268.  
  1269. /* if (tcpinitok) Stask(); */
  1270.  
  1271. switch(eventptr->what) {
  1272.     case mouseDown:
  1273.         return(false);
  1274.     case keyDown:
  1275.         i = (eventptr->message & 0x7f);    /* ascii code */
  1276.         if ((i == 0x03) || (i == 0x0d)) {
  1277.             (*itemptr) = 1;
  1278.             return(true);
  1279.             }
  1280.     default:
  1281.         return(false);
  1282.     }
  1283. }
  1284.  
  1285. pascal Boolean pDlgFilter(dlg, eventptr, itemptr)
  1286. DialogPeek dlg;
  1287. EventRecord * eventptr;
  1288. short * itemptr;
  1289. {
  1290. unsigned char i;
  1291. Point mouseLoc;
  1292. short gtype;
  1293. Handle gitem;
  1294. Rect gbox;
  1295. GrafPtr gp;
  1296.  
  1297. /* if (tcpinitok) Stask(); */
  1298.  
  1299. switch(eventptr->what) {
  1300.     case mouseDown:
  1301.         if (hidden) {
  1302.             GetPort(&gp);
  1303.             SetPort((GrafPtr)dlg);
  1304.             mouseLoc = eventptr->where;
  1305.             GlobalToLocal(&mouseLoc);
  1306.             SetPort(gp);
  1307.             GetDItem((DialogPtr)dlg, 13, >ype, &gitem, &gbox);
  1308.             if (PtInRect(mouseLoc, &gbox)) {
  1309.                 SetIText(gitem, "\p");
  1310.                 memset(passtext, 0, 32);
  1311.                 hidden = 0;
  1312.                 }
  1313.             }
  1314.         return(false);
  1315.         break;
  1316.     case keyDown:
  1317.     case autoKey:
  1318.         i = (eventptr->message & 0x7f);    /* ascii code */
  1319.         if ((i == 0x03) || (i == 0x0d)) {
  1320.             (*itemptr) = 1;
  1321.             return(true);
  1322.             }
  1323.         if ((i == 0x09) && (dlg->editField == 10) && hidden) {
  1324.             GetDItem((DialogPtr)dlg, 13, >ype, &gitem, &gbox);
  1325.             SetIText(gitem, "\p");
  1326.             memset(passtext, 0, 32);
  1327.             hidden = 0;
  1328.             return(false);
  1329.             }
  1330.         if ((dlg->editField == 12) && (i != 0x09)) {
  1331.             updpass((*(dlg->textH))->selStart, (*(dlg->textH))->selEnd, i);
  1332.             if ((i > 0x20) && (i <= 0x7e)) eventptr->message = 0xa5;
  1333.             return(false);
  1334.             }
  1335.     default:
  1336.         return(false);
  1337.     }
  1338. }
  1339.  
  1340. void updpass(start, end, c)
  1341. short start, end;
  1342. unsigned char c;
  1343. {
  1344. unsigned char origtext[32];
  1345. unsigned char newstr[2];
  1346.  
  1347. memcpy(origtext, passtext, 32);            /* copy current text */
  1348. memset(passtext, 0, 32);                /* clear password */
  1349. newstr[0] = c;                            /* define string for new character */
  1350. newstr[1] = 0;
  1351.  
  1352. /* if character is a backspace, and have insertion point, 
  1353.    change to selection range of the previous character (if any) */
  1354.  
  1355. if ((start == end) && (c == 0x08))
  1356.     if (start > 0) start--;
  1357.  
  1358. /* ignore changes after the first 31 characters */
  1359. if (start > 31) start = 31;
  1360. if (end > 31) end = 31;
  1361.  
  1362. /* copy text up to insertion point or selection range */
  1363. appendpass(origtext, start);
  1364.  
  1365. /* if character is not a backspace, append character */
  1366. if (c != 0x08) appendpass(newstr, 1);
  1367.  
  1368. /* append text following insertion point or selection range */
  1369. appendpass(origtext+end, strlen(origtext)-end);
  1370. }
  1371.  
  1372. void appendpass(s, len)
  1373. unsigned char * s;
  1374. short len;
  1375. {
  1376. short slen, plen, rlen;
  1377.  
  1378. /* check for arguments indicating nothing to do */
  1379. if ((s[0] == 0) || (len < 1)) return;
  1380.  
  1381. /* reduce length if longer than characters present */
  1382. slen = strlen(s);
  1383. if (slen < len) len = slen;
  1384.  
  1385. /* reduce length if too many to fit */
  1386. plen = strlen(passtext);
  1387. rlen = 31 - plen;
  1388. if (len > rlen) len = rlen;
  1389.  
  1390. if (len == 0) return;
  1391. memcpy(passtext+plen, s, len); 
  1392. }
  1393.  
  1394. void setit(item, dlgptr, code)
  1395. register short item, code;
  1396. register DialogPtr dlgptr;
  1397. {
  1398. short gtype;
  1399. Handle gitem;
  1400. Rect gbox;
  1401.  
  1402. GetDItem(dlgptr, item, >ype, &gitem, &gbox);
  1403. SetCtlValue((ControlHandle)gitem, code);
  1404. }
  1405.  
  1406. void ctrwindow(wp)
  1407. GrafPtr wp;
  1408. {
  1409. short scrhsize, scrvsize;
  1410. short whsize, wvsize;
  1411.  
  1412. scrhsize = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
  1413. scrvsize = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top;
  1414. whsize = wp->portRect.right-wp->portRect.left;
  1415. wvsize = wp->portRect.bottom - wp->portRect.top;
  1416. if (bigscreen)
  1417.     MoveWindow(wp, (scrhsize-whsize)/2, (scrvsize-wvsize)/3, 0);
  1418. else
  1419.     MoveWindow(wp, (scrhsize-whsize)/2, (scrvsize-wvsize)/2, 0);
  1420. }
  1421.  
  1422. void ctralrt(a)
  1423. short a;        /* alert number */
  1424. {
  1425. Handle reshnd;
  1426. struct Rect * rptr;
  1427. short scrhsize, scrvsize;
  1428. short ahsize, avsize;
  1429.  
  1430. CouldAlert(a);        /* read alert into memory and make unpurgeable */
  1431. reshnd = GetResource('ALRT', a);
  1432. if (reshnd == 0) return;
  1433. rptr = (struct Rect *)*reshnd;
  1434. scrhsize = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
  1435. scrvsize = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top;
  1436. ahsize = rptr->right - rptr->left;
  1437. avsize = rptr->bottom - rptr->top;
  1438. if (bigscreen)
  1439.     rptr->top = (scrvsize-avsize)/3;
  1440. else
  1441.     rptr->top = (scrvsize-avsize)/2;
  1442. rptr->left = (scrhsize-ahsize)/2;
  1443. rptr->bottom = rptr->top + avsize;
  1444. rptr->right = rptr->left + ahsize;
  1445. }
  1446.  
  1447. void framedflt(dlgptr)
  1448. DialogPtr dlgptr;
  1449. {
  1450. short gtype;
  1451. Handle gitem;
  1452. Rect gbox;
  1453. GrafPtr gp;
  1454.  
  1455. GetDItem(dlgptr, 1, >ype, &gitem, &gbox);
  1456. GetPort(&gp);
  1457. SetPort(dlgptr);
  1458. PenSize(3,3);
  1459. InsetRect(&gbox, -4, -4);
  1460. FrameRoundRect(&gbox, 16, 16);
  1461. SetPort(gp);
  1462. }
  1463.  
  1464. short getstring(dlgptr, item, desc, s, size)
  1465. DialogPtr dlgptr;
  1466. short item, size;
  1467. unsigned char * desc, * s;
  1468. {
  1469. short gtype;
  1470. Handle gitem;
  1471. Rect gbox;
  1472. unsigned char result[256];
  1473.  
  1474. GetDItem(dlgptr, item, >ype, &gitem, &gbox);
  1475. GetIText(gitem, result);
  1476. p2cstr(result);
  1477.  
  1478. return(checkstring(result, dlgptr, item, desc, s, size));
  1479. }
  1480.  
  1481. short checkstring(result, dlgptr, item, desc, s, size)
  1482. DialogPtr dlgptr;
  1483. short item, size;
  1484. unsigned char * result, * desc, * s;
  1485. {
  1486. unsigned char * start;
  1487. short i, len;
  1488. pascal Boolean (*filterProc) ();
  1489. unsigned char blankflag;
  1490. static unsigned char nullstr[1] = {0};
  1491. unsigned char chkmsg[64];
  1492.  
  1493. filterProc = DlgFilter;
  1494.  
  1495. /* set start and len to remove leading and trailing blanks */
  1496. start = result;
  1497. while (start[0] == ' ') start++;
  1498. len = strlen(start);
  1499. if (len > 0) while (start[len-1] == ' ') len--;
  1500.  
  1501. /* check for length error */
  1502. if (len > size-1) {
  1503.     if (size == 2 ) {
  1504.         sprintf(chkmsg, "\"%s\" cannot exceed 1 character.",
  1505.                 desc);
  1506.         }
  1507.     else {
  1508.         sprintf(chkmsg, "\"%s\" cannot exceed %d characters.",
  1509.                 desc, size-1);
  1510.         }
  1511.     c2pstr(chkmsg);
  1512.     ParamText(chkmsg, nullstr, nullstr, nullstr);
  1513.     p2cstr(chkmsg);
  1514.     StopAlert(258, (ModalFilterProcPtr)filterProc);
  1515.     ParamText(nullstr, nullstr, nullstr, nullstr);
  1516.     if (dlgptr != 0) SelIText(dlgptr, item, 0, 32767);
  1517.     return(1);
  1518.     }
  1519.  
  1520. /* check for embedded blanks */
  1521. blankflag = 0;
  1522. if (len > 0)
  1523.     for (i=0; i < len; i++)
  1524.         if (start[i] == ' ') {
  1525.             blankflag = 1;
  1526.             break;
  1527.             }
  1528. if (blankflag) {
  1529.     sprintf(chkmsg, "\"%s\" cannot contain blanks.", desc);
  1530.     c2pstr(chkmsg);
  1531.     ParamText(chkmsg, nullstr, nullstr, nullstr);
  1532.     p2cstr(chkmsg);
  1533.     StopAlert(258, (ModalFilterProcPtr)filterProc);
  1534.     ParamText(nullstr, nullstr, nullstr, nullstr);
  1535.     if (dlgptr != 0) SelIText(dlgptr, item, 0, 32767);
  1536.     return(2);
  1537.     }
  1538.  
  1539. /* copy result */
  1540. memset(s, 0, size);
  1541. memcpy(s, start, len);
  1542. return(0);
  1543. }
  1544.  
  1545. short getcnum(dlgptr, item, desc, n, minval, maxval)
  1546. DialogPtr dlgptr;
  1547. short item, minval, maxval;
  1548. unsigned char * desc;
  1549. unsigned char * n;
  1550. {
  1551. short gtype;
  1552. Handle gitem;
  1553. Rect gbox;
  1554. unsigned char result[256];
  1555.  
  1556. GetDItem(dlgptr, item, >ype, &gitem, &gbox);
  1557. GetIText(gitem, result);
  1558. p2cstr(result);
  1559.  
  1560. return(checknum(result, dlgptr, item, desc, n, minval, maxval));
  1561. }
  1562.  
  1563. short checknum(result, dlgptr, item, desc, n, minval, maxval)
  1564. DialogPtr dlgptr;
  1565. short item, minval, maxval;
  1566. unsigned char * result, * desc;
  1567. unsigned char * n;
  1568. {
  1569. unsigned char * start;
  1570. short i, len;
  1571. pascal Boolean (*filterProc) ();
  1572. unsigned char digitflag;
  1573. static unsigned char nullstr[1] = {0};
  1574. unsigned char chkmsg[64];
  1575.  
  1576. filterProc = DlgFilter;
  1577.  
  1578. /* set start and len to remove leading and trailing blanks */
  1579. start = result;
  1580. while (start[0] == ' ') start++;
  1581. len = strlen(start);
  1582. if (len > 0) while (start[len-1] == ' ') len--;
  1583.  
  1584. /* check for valid digits */
  1585. digitflag = 0;
  1586. if (len > 0)
  1587.     for (i=0; i < len; i++)
  1588.         if (!isdigit(start[i])) {
  1589.             digitflag = 1;
  1590.             break;
  1591.             }
  1592. if (digitflag) {
  1593.     sprintf(chkmsg, "\"%s\" contains characters which are not digits.", desc);
  1594.     c2pstr(chkmsg);
  1595.     ParamText(chkmsg, nullstr, nullstr, nullstr);
  1596.     p2cstr(chkmsg);
  1597.     StopAlert(258, (ModalFilterProcPtr)filterProc);
  1598.     ParamText(nullstr, nullstr, nullstr, nullstr);
  1599.     if (dlgptr != 0) SelIText(dlgptr, item, 0, 32767);
  1600.     return(1);
  1601.     }
  1602. start[len] = 0;
  1603. if (len == 0) i = 0;
  1604. else i = atoi(start);
  1605. if (((i < minval) || (i > maxval)) && (i != 0)) {
  1606.     sprintf(chkmsg, "\"%s\" must be between %d and %d.", desc, minval, maxval);
  1607.     c2pstr(chkmsg);
  1608.     ParamText(chkmsg, nullstr, nullstr, nullstr);
  1609.     p2cstr(chkmsg);
  1610.     StopAlert(258, (ModalFilterProcPtr)filterProc);
  1611.     ParamText(nullstr, nullstr, nullstr, nullstr);
  1612.     if (dlgptr != 0) SelIText(dlgptr, item, 0, 32767);
  1613.     return(2);
  1614.     }
  1615. (*n) = i;        /* store result */
  1616. return(0);
  1617. }
  1618.